// SmarTest Studio - ProjectManager类

import { showNotification } from './utils.js';
import http from './http-client.js';

/**
 * ProjectManager类 - 负责项目批量操作功能
 */
export class ProjectManager {
    constructor() {
        // 项目表格和选中项目的数组
        this.projectsTable = document.getElementById('projectsTable');
        this.selectedProjects = [];
        
        // 绑定方法到实例
        this.initProjectOperations = this.initProjectOperations.bind(this);
        this.handleProjectSelection = this.handleProjectSelection.bind(this);
        this.toggleProjectSelection = this.toggleProjectSelection.bind(this);
        this.selectProjectRange = this.selectProjectRange.bind(this);
        this.clearAllSelections = this.clearAllSelections.bind(this);
        this.updateButtonStates = this.updateButtonStates.bind(this);
        this.showImportDialog = this.showImportDialog.bind(this);
        this.processImportedProjects = this.processImportedProjects.bind(this);
        this.importProjects = this.importProjects.bind(this);
        this.checkImportCompletion = this.checkImportCompletion.bind(this);
        this.showExportDialog = this.showExportDialog.bind(this);
        this.getDefaultExportPath = this.getDefaultExportPath.bind(this);
        this.exportProjects = this.exportProjects.bind(this);
        this.confirmDeleteProjects = this.confirmDeleteProjects.bind(this);
        this.deleteProjects = this.deleteProjects.bind(this);
    }
    
    /**
     * 初始化项目操作功能
     * @param {Function} loadProjectsCallback - 加载项目的回调函数
     */
    initProjectOperations(loadProjectsCallback) {
        // 保存加载项目的回调函数
        this.loadProjectsCallback = loadProjectsCallback;
        
        // 获取按钮元素
        const importProjectsBtn = document.getElementById('import_projects');
        const exportProjectsBtn = document.getElementById('export_projects');
        const deleteProjectsBtn = document.getElementById('delete_projects');
        
        // 为导入按钮添加点击事件
        if (importProjectsBtn) {
            importProjectsBtn.addEventListener('click', this.showImportDialog);
        }
        
        // 为导出按钮添加点击事件
        if (exportProjectsBtn) {
            exportProjectsBtn.addEventListener('click', this.showExportDialog);
        }
        
        // 为删除按钮添加点击事件
        if (deleteProjectsBtn) {
            deleteProjectsBtn.addEventListener('click', this.confirmDeleteProjects);
        }
        
        // 为项目表格添加点击事件，实现项目选择功能
        if (this.projectsTable) {
            this.projectsTable.addEventListener('click', this.handleProjectSelection);
        }
        
        // 点击页面其他区域取消所有选择
        document.addEventListener('click', (event) => {
            // 如果点击的不是项目表格内的元素，则取消所有选择
            if (this.projectsTable && !this.projectsTable.contains(event.target)) {
                this.clearAllSelections();
            }
        });
    }
    
    /**
     * 处理项目选择
     * @param {Event} event - 点击事件
     */
    handleProjectSelection(event) {
        // 获取点击的行元素
        const row = event.target.closest('tr');
        if (!row) return;
        
        // 获取项目名称和所有者
        const projectName = row.getAttribute('data-project-name');
        const projectOwner = row.getAttribute('data-project-owner');
        if (!projectName || !projectOwner) return;
        
        // 创建项目标识符
        const projectId = `${projectOwner}:${projectName}`;
        
        // 阻止事件冒泡，防止点击行内按钮时触发选择
        if (event.target.closest('.btn-group')) {
            return;
        }
        
        // 处理Ctrl键和Shift键的多选
        if (event.ctrlKey) {
            // Ctrl+点击：切换单个项目的选择状态
            this.toggleProjectSelection(row, projectId);
        } else if (event.shiftKey && this.selectedProjects.length > 0) {
            // Shift+点击：选择范围
            this.selectProjectRange(row, projectId);
        } else {
            // 普通点击：清除其他选择，只选择当前项目
            this.clearAllSelections();
            this.toggleProjectSelection(row, projectId);
        }
        
        // 更新导出和删除按钮的状态
        this.updateButtonStates();
    }
    
    /**
     * 切换项目选择状态
     * @param {HTMLElement} row - 项目行元素
     * @param {string} projectId - 项目ID
     */
    toggleProjectSelection(row, projectId) {
        const index = this.selectedProjects.indexOf(projectId);
        
        if (index === -1) {
            // 如果项目未被选中，则添加到选中列表并更新样式
            this.selectedProjects.push(projectId);
            row.classList.add('selected-project');
        } else {
            // 如果项目已被选中，则从选中列表中移除并更新样式
            this.selectedProjects.splice(index, 1);
            row.classList.remove('selected-project');
        }
    }
    
    /**
     * 选择项目范围（Shift+点击）
     * @param {HTMLElement} targetRow - 目标行元素
     * @param {string} targetProjectId - 目标项目ID
     */
    selectProjectRange(targetRow, targetProjectId) {
        // 获取所有项目行
        const rows = Array.from(document.querySelectorAll('#projectsTable tr'));
        
        // 找到最后一个选中的项目行
        const lastSelectedId = this.selectedProjects[this.selectedProjects.length - 1];
        const [lastOwner, lastName] = lastSelectedId.split(':');
        const lastSelectedRow = document.querySelector(`#projectsTable tr[data-project-name="${lastName}"][data-project-owner="${lastOwner}"]`);
        
        // 获取起始和结束索引
        const startIndex = rows.indexOf(lastSelectedRow);
        const endIndex = rows.indexOf(targetRow);
        
        // 清除所有选择
        this.clearAllSelections();
        
        // 选择范围内的所有项目
        const start = Math.min(startIndex, endIndex);
        const end = Math.max(startIndex, endIndex);
        
        for (let i = start; i <= end; i++) {
            const row = rows[i];
            const projectName = row.getAttribute('data-project-name');
            const projectOwner = row.getAttribute('data-project-owner');
            if (projectName && projectOwner) {
                const projectId = `${projectOwner}:${projectName}`;
                this.selectedProjects.push(projectId);
                row.classList.add('selected-project');
            }
        }
    }
    
    /**
     * 清除所有选择
     */
    clearAllSelections() {
        // 清除选中项目数组
        this.selectedProjects = [];
        
        // 移除所有选中样式
        const selectedRows = document.querySelectorAll('.selected-project');
        selectedRows.forEach(row => row.classList.remove('selected-project'));
        
        // 更新按钮状态
        this.updateButtonStates();
    }
    
    /**
     * 更新导出和删除按钮的状态
     */
    updateButtonStates() {
        const exportBtn = document.getElementById('export_projects');
        const deleteBtn = document.getElementById('delete_projects');
        
        if (this.selectedProjects.length > 0) {
            // 有选中的项目，启用按钮
            if (exportBtn) exportBtn.disabled = false;
            if (deleteBtn) deleteBtn.disabled = false;
        } else {
            // 没有选中的项目，禁用按钮
            if (exportBtn) exportBtn.disabled = true;
            if (deleteBtn) deleteBtn.disabled = true;
        }
    }
    
    /**
     * 显示导入对话框
     */
    showImportDialog() {
        // 显示导入项目模态框
        const importModal = new bootstrap.Modal(document.getElementById('importProjectsModal'));
        importModal.show();
        
        // 处理确认按钮点击事件
        document.getElementById('confirmImportBtn').addEventListener('click', () => {
            const importInput = document.getElementById('importProjectsInput');
            const files = importInput.files;
            
            if (files.length > 0) {
                importModal.hide();
                this.processImportedProjects(files);
            } else {
                alert('请选择包含项目配置文件的目录');
            }
        });
    }
    
    /**
     * 处理导入的项目
     * @param {FileList} files - 导入的文件列表
     */
    processImportedProjects(files) {
        // 显示加载指示器
        showNotification('正在处理导入的项目...', 'info');
        
        // 创建一个数组来存储项目配置文件
        const projectConfigs = [];
        
        // 遍历所有文件，查找项目配置文件
        for (let i = 0; i < files.length; i++) {
            const file = files[i];
            const filePath = file.webkitRelativePath;
            
            // 检查是否是项目配置文件（假设配置文件名为project.json或config.json）
            if (filePath.endsWith('project.json') || filePath.endsWith('config.json')) {
                // 读取配置文件内容
                const reader = new FileReader();
                reader.onload = (e) => {
                    try {
                        const config = JSON.parse(e.target.result);
                        // 添加文件路径信息
                        config.filePath = filePath;
                        projectConfigs.push(config);
                        
                        // 如果已处理完所有文件，则导入项目
                        if (projectConfigs.length === files.length) {
                            this.importProjects(projectConfigs);
                        }
                    } catch (error) {
                        console.error('解析项目配置文件失败:', error);
                        showNotification(`解析项目配置文件 ${filePath} 失败`, 'danger');
                    }
                };
                reader.readAsText(file);
            }
        }
        
        // 如果没有找到任何配置文件
        if (projectConfigs.length === 0) {
            showNotification('未找到有效的项目配置文件', 'warning');
        }
    }
    
    /**
     * 导入项目
     * @param {Array} projectConfigs - 项目配置数组
     */
    importProjects(projectConfigs) {
        // 显示加载指示器
        showNotification(`正在导入 ${projectConfigs.length} 个项目...`, 'info');
        
        // 创建一个计数器来跟踪成功和失败的导入
        let successCount = 0;
        let failureCount = 0;
        
        // 遍历所有项目配置
        projectConfigs.forEach(config => {
            // 构建POST请求数据
            const postData = {
                api: 'import_project',
                name: config.name || '未命名项目',
                type: config.type || 'UiTest',
                platform: config.platform || 'hos',
                version: config.version || '1.0',
                desc: config.description || '',
                config: config // 包含完整配置
            };
            
            // 发送POST请求创建新项目
            http.post('/api/projects', postData)
                .then((response) => {
                    successCount++;
                    this.checkImportCompletion(successCount, failureCount, projectConfigs.length);
                })
                .catch((error) => {
                    console.error('导入项目失败:', error);
                    failureCount++;
                    this.checkImportCompletion(successCount, failureCount, projectConfigs.length);
                });
        });
    }
    
    /**
     * 检查导入完成状态
     * @param {number} successCount - 成功导入的项目数
     * @param {number} failureCount - 导入失败的项目数
     * @param {number} totalCount - 总项目数
     */
    checkImportCompletion(successCount, failureCount, totalCount) {
        if (successCount + failureCount === totalCount) {
            // 所有导入请求已完成
            if (failureCount === 0) {
                showNotification(`成功导入 ${successCount} 个项目`, 'success');
            } else {
                showNotification(`导入完成: ${successCount} 个成功, ${failureCount} 个失败`, 'warning');
            }
            
            // 重新加载项目列表
            if (this.loadProjectsCallback) {
                this.loadProjectsCallback();
            }
        }
    }
    
    /**
     * 显示导出对话框
     */
    showExportDialog() {
        if (this.selectedProjects.length === 0) {
            showNotification('请先选择要导出的项目', 'warning');
            return;
        }
        
        // 设置默认导出路径
        document.getElementById('exportPath').value = this.getDefaultExportPath();
        
        // 显示导出项目模态框
        const exportModal = new bootstrap.Modal(document.getElementById('exportProjectsModal'));
        exportModal.show();
        
        // 处理确认按钮点击事件
        document.getElementById('confirmExportBtn').addEventListener('click', () => {
            const exportPath = document.getElementById('exportPath').value;
            if (exportPath) {
                exportModal.hide();
                this.exportProjects(exportPath);
            } else {
                alert('请输入有效的导出路径');
            }
        });
    }
    
    /**
     * 获取默认导出路径
     * @returns {string} - 默认导出路径
     */
    getDefaultExportPath() {
        // 这里可以根据实际情况设置默认路径
        return '/home/user/exported_projects';
    }
    
    /**
     * 导出项目
     * @param {string} exportPath - 导出路径
     */
    exportProjects(exportPath) {
        // 显示加载指示器
        showNotification(`正在导出 ${this.selectedProjects.length} 个项目...`, 'info');
        
        // 构建POST请求数据
        const postData = {
            api: 'export_projects',
            project_ids: this.selectedProjects,
            export_path: exportPath
        };
        
        // 发送POST请求导出项目
        http.post('/api/projects', postData)
            .then((response) => {
                const result = response.data;
                if (result.success) {
                    showNotification(`成功导出 ${result.exported_count} 个项目到 ${exportPath}`, 'success');
                } else {
                    showNotification(`导出失败: ${result.error}`, 'danger');
                }
            })
            .catch((error) => {
                console.error('导出项目失败:', error);
                showNotification('导出项目失败', 'danger');
            });
    }
    
    /**
     * 确认删除项目
     */
    confirmDeleteProjects() {
        if (this.selectedProjects.length === 0) {
            showNotification('请先选择要删除的项目', 'warning');
            return;
        }
        
        // 创建确认对话框
        if (confirm(`确定要删除选中的 ${this.selectedProjects.length} 个项目吗？此操作不可撤销。`)) {
            this.deleteProjects();
        }
    }
    
    /**
     * 删除项目
     */
    deleteProjects() {
        // 显示加载指示器
        showNotification(`正在删除 ${this.selectedProjects.length} 个项目...`, 'info');
        
        // 构建POST请求数据
        const postData = {
            api: 'delete_projects',
            project_ids: this.selectedProjects
        };
        
        // 发送POST请求删除项目
        http.post('/api/projects', postData)
            .then((response) => {
                const result = response.data;
                if (result.success) {
                    showNotification(`成功删除 ${result.deleted_count} 个项目`, 'success');
                    // 清除选择并重新加载项目列表
                    this.clearAllSelections();
                    if (this.loadProjectsCallback) {
                        this.loadProjectsCallback();
                    }
                } else {
                    showNotification(`删除失败: ${result.error}`, 'danger');
                }
            })
            .catch((error) => {
                console.error('删除项目失败:', error);
                showNotification('删除项目失败', 'danger');
            });
    }
}